package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade CRITERIO_APROVACAO_ENSAIO
 * @author Gerado pelo Telescope
 */
public class EntCriterioAprovacaoEnsaio extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.CRITERIO_APROVACAO_ENSAIO";
    public final static String TABLE_NAME = "CRITERIO_APROVACAO_ENSAIO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntCriterioAprovacaoEnsaio() {
        super();
        initialize();
    }
    
    public EntCriterioAprovacaoEnsaio(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aNome = new DomUpper(this,"NOME", "Nome do critério de aprovação"); 
        aNome.setRequired(true);
        aNome.setSize(64);
        oNome = new DomUpper();
        aPercentualErroMinimoInferior = new DomPercent(this,"PERCENTUAL_ERRO_MINIMO_INFERIOR", "% de erro mínimo (campo inferior)"); 
        aPercentualErroMinimoInferior.setRequired(true);
        oPercentualErroMinimoInferior = new DomPercent();
        aPercentualErroMaximoInferior = new DomPercent(this,"PERCENTUAL_ERRO_MAXIMO_INFERIOR", "% de erro máximo (campo inferior)"); 
        aPercentualErroMaximoInferior.setRequired(true);
        oPercentualErroMaximoInferior = new DomPercent();
        aExigeSinalDiferente = new DomFlag(this,"EXIGE_SINAL_DIFERENTE", "Exige percentual de erro com sinal distinto"); 
        aExigeSinalDiferente.setRequired(true);
        aExigeSinalDiferente.setDefaultValue("S");
        oExigeSinalDiferente = new DomFlag();
        aPercentualErroMinimoSuperior = new DomPercent(this,"PERCENTUAL_ERRO_MINIMO_SUPERIOR", "% de erro mínimo (campo superior)"); 
        aPercentualErroMinimoSuperior.setRequired(true);
        oPercentualErroMinimoSuperior = new DomPercent();
        aPercentualErroMaximoSuperior = new DomPercent(this,"PERCENTUAL_ERRO_MAXIMO_SUPERIOR", "% de erro máximo (campo superior)"); 
        aPercentualErroMaximoSuperior.setRequired(true);
        oPercentualErroMaximoSuperior = new DomPercent();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Nome do critério de aprovação
    private DomUpper aNome;
    private DomUpper oNome;
    
    // % de erro mínimo (campo inferior)
    private DomPercent aPercentualErroMinimoInferior;
    private DomPercent oPercentualErroMinimoInferior;
    
    // % de erro máximo (campo inferior)
    private DomPercent aPercentualErroMaximoInferior;
    private DomPercent oPercentualErroMaximoInferior;
    
    // Exige percentual de erro com sinal distinto
    private DomFlag aExigeSinalDiferente;
    private DomFlag oExigeSinalDiferente;
    
    // % de erro mínimo (campo superior)
    private DomPercent aPercentualErroMinimoSuperior;
    private DomPercent oPercentualErroMinimoSuperior;
    
    // % de erro máximo (campo superior)
    private DomPercent aPercentualErroMaximoSuperior;
    private DomPercent oPercentualErroMaximoSuperior;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntCriterioAprovacaoEnsaio id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NOME">
    
    public EntCriterioAprovacaoEnsaio nome(String value) {
        setNome(value);
        return this;
    }
    
    public void setNome(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyNome();
        } else {
            aNome.setValue(value.getValue());
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(String value) {
        if (value == null) {
            nullifyNome();
        } else {
            aNome.setValue(value);
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(Object value) {
        aNome.setValue(value);
        if (aNome.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNome() {
        if (!aNome.isNull()) {
            aNome.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getNome() {
        return aNome;
    }
    
    public DomUpper oldNome() {
        return oNome;
    }
    
    public String valueOfNome() {
        return aNome.getValue();
    }
    
    public boolean isNomeModified() {
        return aNome.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PERCENTUAL_ERRO_MINIMO_INFERIOR">
    
    public EntCriterioAprovacaoEnsaio percentualErroMinimoInferior(Double value) {
        setPercentualErroMinimoInferior(value);
        return this;
    }
    
    public void setPercentualErroMinimoInferior(DomPercent value) {
        if (value == null || value.isNull()) {
            nullifyPercentualErroMinimoInferior();
        } else {
            aPercentualErroMinimoInferior.setValue(value.getValue());
            if (aPercentualErroMinimoInferior.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPercentualErroMinimoInferior(String value) {
        if (value == null) {
            nullifyPercentualErroMinimoInferior();
        } else {
            aPercentualErroMinimoInferior.setValue(value);
            if (aPercentualErroMinimoInferior.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPercentualErroMinimoInferior(Double value) {
        aPercentualErroMinimoInferior.setValue(value);
        if (aPercentualErroMinimoInferior.isModified()) {
            setModified(true);
        }
    }
    
    public void setPercentualErroMinimoInferior(Object value) {
        aPercentualErroMinimoInferior.setValue(value);
        if (aPercentualErroMinimoInferior.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPercentualErroMinimoInferior() {
        if (!aPercentualErroMinimoInferior.isNull()) {
            aPercentualErroMinimoInferior.setNull(true);
            setModified(true);
        }
    }
    
    public DomPercent getPercentualErroMinimoInferior() {
        return aPercentualErroMinimoInferior;
    }
    
    public DomPercent oldPercentualErroMinimoInferior() {
        return oPercentualErroMinimoInferior;
    }
    
    public Double valueOfPercentualErroMinimoInferior() {
        return aPercentualErroMinimoInferior.getValue();
    }
    
    public boolean isPercentualErroMinimoInferiorModified() {
        return aPercentualErroMinimoInferior.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PERCENTUAL_ERRO_MAXIMO_INFERIOR">
    
    public EntCriterioAprovacaoEnsaio percentualErroMaximoInferior(Double value) {
        setPercentualErroMaximoInferior(value);
        return this;
    }
    
    public void setPercentualErroMaximoInferior(DomPercent value) {
        if (value == null || value.isNull()) {
            nullifyPercentualErroMaximoInferior();
        } else {
            aPercentualErroMaximoInferior.setValue(value.getValue());
            if (aPercentualErroMaximoInferior.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPercentualErroMaximoInferior(String value) {
        if (value == null) {
            nullifyPercentualErroMaximoInferior();
        } else {
            aPercentualErroMaximoInferior.setValue(value);
            if (aPercentualErroMaximoInferior.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPercentualErroMaximoInferior(Double value) {
        aPercentualErroMaximoInferior.setValue(value);
        if (aPercentualErroMaximoInferior.isModified()) {
            setModified(true);
        }
    }
    
    public void setPercentualErroMaximoInferior(Object value) {
        aPercentualErroMaximoInferior.setValue(value);
        if (aPercentualErroMaximoInferior.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPercentualErroMaximoInferior() {
        if (!aPercentualErroMaximoInferior.isNull()) {
            aPercentualErroMaximoInferior.setNull(true);
            setModified(true);
        }
    }
    
    public DomPercent getPercentualErroMaximoInferior() {
        return aPercentualErroMaximoInferior;
    }
    
    public DomPercent oldPercentualErroMaximoInferior() {
        return oPercentualErroMaximoInferior;
    }
    
    public Double valueOfPercentualErroMaximoInferior() {
        return aPercentualErroMaximoInferior.getValue();
    }
    
    public boolean isPercentualErroMaximoInferiorModified() {
        return aPercentualErroMaximoInferior.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo EXIGE_SINAL_DIFERENTE">
    
    public EntCriterioAprovacaoEnsaio exigeSinalDiferente(String value) {
        setExigeSinalDiferente(value);
        return this;
    }
    
    public void setExigeSinalDiferente(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyExigeSinalDiferente();
        } else {
            aExigeSinalDiferente.setValue(value.getValue());
            if (aExigeSinalDiferente.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setExigeSinalDiferente(String value) {
        if (value == null) {
            nullifyExigeSinalDiferente();
        } else {
            aExigeSinalDiferente.setValue(value);
            if (aExigeSinalDiferente.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setExigeSinalDiferente(Object value) {
        aExigeSinalDiferente.setValue(value);
        if (aExigeSinalDiferente.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyExigeSinalDiferente() {
        if (!aExigeSinalDiferente.isNull()) {
            aExigeSinalDiferente.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getExigeSinalDiferente() {
        return aExigeSinalDiferente;
    }
    
    public DomFlag oldExigeSinalDiferente() {
        return oExigeSinalDiferente;
    }
    
    public String valueOfExigeSinalDiferente() {
        return aExigeSinalDiferente.getValue();
    }
    
    public boolean isExigeSinalDiferenteModified() {
        return aExigeSinalDiferente.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PERCENTUAL_ERRO_MINIMO_SUPERIOR">
    
    public EntCriterioAprovacaoEnsaio percentualErroMinimoSuperior(Double value) {
        setPercentualErroMinimoSuperior(value);
        return this;
    }
    
    public void setPercentualErroMinimoSuperior(DomPercent value) {
        if (value == null || value.isNull()) {
            nullifyPercentualErroMinimoSuperior();
        } else {
            aPercentualErroMinimoSuperior.setValue(value.getValue());
            if (aPercentualErroMinimoSuperior.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPercentualErroMinimoSuperior(String value) {
        if (value == null) {
            nullifyPercentualErroMinimoSuperior();
        } else {
            aPercentualErroMinimoSuperior.setValue(value);
            if (aPercentualErroMinimoSuperior.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPercentualErroMinimoSuperior(Double value) {
        aPercentualErroMinimoSuperior.setValue(value);
        if (aPercentualErroMinimoSuperior.isModified()) {
            setModified(true);
        }
    }
    
    public void setPercentualErroMinimoSuperior(Object value) {
        aPercentualErroMinimoSuperior.setValue(value);
        if (aPercentualErroMinimoSuperior.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPercentualErroMinimoSuperior() {
        if (!aPercentualErroMinimoSuperior.isNull()) {
            aPercentualErroMinimoSuperior.setNull(true);
            setModified(true);
        }
    }
    
    public DomPercent getPercentualErroMinimoSuperior() {
        return aPercentualErroMinimoSuperior;
    }
    
    public DomPercent oldPercentualErroMinimoSuperior() {
        return oPercentualErroMinimoSuperior;
    }
    
    public Double valueOfPercentualErroMinimoSuperior() {
        return aPercentualErroMinimoSuperior.getValue();
    }
    
    public boolean isPercentualErroMinimoSuperiorModified() {
        return aPercentualErroMinimoSuperior.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PERCENTUAL_ERRO_MAXIMO_SUPERIOR">
    
    public EntCriterioAprovacaoEnsaio percentualErroMaximoSuperior(Double value) {
        setPercentualErroMaximoSuperior(value);
        return this;
    }
    
    public void setPercentualErroMaximoSuperior(DomPercent value) {
        if (value == null || value.isNull()) {
            nullifyPercentualErroMaximoSuperior();
        } else {
            aPercentualErroMaximoSuperior.setValue(value.getValue());
            if (aPercentualErroMaximoSuperior.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPercentualErroMaximoSuperior(String value) {
        if (value == null) {
            nullifyPercentualErroMaximoSuperior();
        } else {
            aPercentualErroMaximoSuperior.setValue(value);
            if (aPercentualErroMaximoSuperior.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPercentualErroMaximoSuperior(Double value) {
        aPercentualErroMaximoSuperior.setValue(value);
        if (aPercentualErroMaximoSuperior.isModified()) {
            setModified(true);
        }
    }
    
    public void setPercentualErroMaximoSuperior(Object value) {
        aPercentualErroMaximoSuperior.setValue(value);
        if (aPercentualErroMaximoSuperior.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPercentualErroMaximoSuperior() {
        if (!aPercentualErroMaximoSuperior.isNull()) {
            aPercentualErroMaximoSuperior.setNull(true);
            setModified(true);
        }
    }
    
    public DomPercent getPercentualErroMaximoSuperior() {
        return aPercentualErroMaximoSuperior;
    }
    
    public DomPercent oldPercentualErroMaximoSuperior() {
        return oPercentualErroMaximoSuperior;
    }
    
    public Double valueOfPercentualErroMaximoSuperior() {
        return aPercentualErroMaximoSuperior.getValue();
    }
    
    public boolean isPercentualErroMaximoSuperiorModified() {
        return aPercentualErroMaximoSuperior.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.CRITERIO_APROVACAO_PLANO_ENSAIO.FK_CAPLEN_CRITERIO_APROVACAO
        {
            EntCriterioAprovacaoPlanoEnsaio external = new EntCriterioAprovacaoPlanoEnsaio(ctx);
            external.findByCriterioAprovacao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.CRITERIO_APROVACAO_PLANO_ENSAIO.FK_CAPLEN_CRITERIO_APROVACAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Critérios de aprovações dos planos de ensaios fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_CAPLEN_CRITERIO_APROVACAO") >= 0) {
                e = new AdsException("ZTEST.CRITERIO_APROVACAO_PLANO_ENSAIO.FK_CAPLEN_CRITERIO_APROVACAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Critérios de aprovações dos planos de ensaios fazendo referencia para este registro! (FK_CAPLEN_CRITERIO_APROVACAO)");
                return e;
            } else {
                e = new AdsException("ZTEST.CRITERIO_APROVACAO_ENSAIO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("UK_CANOEN_NOME") >= 0) {
                e = new AdsException("ZTEST.CRITERIO_APROVACAO_ENSAIO.UK_CANOEN_NOME", 
                        Severity.ERROR,
                        "Registro duplicado! Nome do critério de aprovação Nome do critério de aprovação ${NOME} (UK_CANOEN_NOME)");
                return e;
            } else if (msg.indexOf("PK_CANOEN") >= 0) {
                e = new AdsException("ZTEST.CRITERIO_APROVACAO_ENSAIO.PK_CANOEN", 
                        Severity.ERROR,
                        "ID duplicado! (PK_CANOEN)");
                return e;
            } else {
                e = new AdsException("ZTEST.CRITERIO_APROVACAO_ENSAIO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aNome);
            allAttributes.add(aPercentualErroMinimoInferior);
            allAttributes.add(aPercentualErroMaximoInferior);
            allAttributes.add(aExigeSinalDiferente);
            allAttributes.add(aPercentualErroMinimoSuperior);
            allAttributes.add(aPercentualErroMaximoSuperior);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getNome().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByNome(String nome) throws AdsException {
        findBy(new String[] {"NOME"},
                new Object[] {nome});
    }
    /**
     * Retorna os registros de CRITERIO_APROVACAO_PLANO_ENSAIO que referenciam este registro através do atributo CRITERIO_APROVACAO_ID
     */
    public EntCriterioAprovacaoPlanoEnsaio findAllCriterioAprovacaoPlanoEnsaioCriterioAprovacao() throws AdsException {
        return findAllCriterioAprovacaoPlanoEnsaioCriterioAprovacao("order by ID");
    }
    
    /**
     * Retorna os registros de CRITERIO_APROVACAO_PLANO_ENSAIO que referenciam este registro através do atributo CRITERIO_APROVACAO_ID
     */
    public EntCriterioAprovacaoPlanoEnsaio findAllCriterioAprovacaoPlanoEnsaioCriterioAprovacao(String sqlAppend) throws AdsException {
        EntCriterioAprovacaoPlanoEnsaio out = new EntCriterioAprovacaoPlanoEnsaio(ctx);
        out.find("select ID from CRITERIO_APROVACAO_PLANO_ENSAIO where CRITERIO_APROVACAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oPercentualErroMaximoSuperior.setValue(aPercentualErroMaximoSuperior);
        oPercentualErroMinimoSuperior.setValue(aPercentualErroMinimoSuperior);
        oPercentualErroMaximoInferior.setValue(aPercentualErroMaximoInferior);
        oPercentualErroMinimoInferior.setValue(aPercentualErroMinimoInferior);
        oExigeSinalDiferente.setValue(aExigeSinalDiferente);
        oNome.setValue(aNome);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntCriterioAprovacaoEnsaio.class);
            rule.setName("PK_CANOEN");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntCriterioAprovacaoEnsaio.class);
            rule.setName("UK_CANOEN_NOME");
            rule.addAttribute(new DomUpper("NOME",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void preUpdate() throws AdsException {
        verificarAtualizacaoCriterio(); //Criterios não podem ser alterados ou excluídos depois de associados ao plano de execução que tem ensaio!
    }
    
    @Override
    protected void preDelete() throws AdsException {
        verificarAtualizacaoCriterio(); //Criterios não podem ser alterados ou excluídos depois de associados ao plano de execução que tem ensaio!
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getExigeSinalDiferente().isNull()) {
            setExigeSinalDiferente(getExigeSinalDiferente().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Regra de ação: Criterios não podem ser alterados ou excluídos depois de associados ao plano de execução que tem ensaio!
     */
    private void verificarAtualizacaoCriterio() throws AdsException {
        // <user-code id="21882686" parentId="21882615" hashcode="-67f13c0c" length="612">
        int qtde = ctx.computeSqlInteger(
                "select count(*)"
                + " from solicitacao_ensaio sole"
                + " join plano_execucao plex on plex.id = sole.plano_execucao_id" 
                + " join criterio_aprovacao_plano_ensaio crpe on crpe.plano_ensaio_id = plex.id"
                + " where crpe.criterio_aprovacao_id = ?"
                + " and sole.situacao = 'E'",
                0, 
                valueOfId().longValue());
        
        if (qtde > 0) {
            ctx.pushError(ENTITY_NAME,
                    Severity.ERROR,
                    "Criterios não podem ser alterados ou excluídos depois de associados ao plano de execução que tem ensaio!");
        }
        // </user-code>
    }
}
